home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / diskBoot.OpenProm / RCS / byte.c,v < prev    next >
Text File  |  1989-06-08  |  7KB  |  279 lines
  1. head     1.1;
  2. access   ;
  3. symbols  ;
  4. locks    ; strict;
  5. comment  @ * @;
  6.  
  7.  
  8. 1.1
  9. date     86.07.18.09.31.27;  author brent;  state Exp;
  10. branches ;
  11. next     ;
  12.  
  13.  
  14. desc
  15. @Slimline version of sprite c library byte.c
  16. @
  17.  
  18.  
  19.  
  20. 1.1
  21. log
  22. @Initial revision
  23. @
  24. text
  25. @/* 
  26.  * byte.c --
  27.  *
  28.  *      Contains routines to do manipulate byte arrays: copying,
  29.  *    clearing, comparison, etc.
  30.  *    SLIMLINE BOOT VERSION
  31.  *
  32.  * Copyright 1985 Regents of the University of California
  33.  * All rights reserved.
  34.  */
  35.  
  36. #ifndef lint
  37. static char rcsid[] = "$Header: byte.c,v 1.4 86/06/29 20:15:46 andrew Exp $ SPRITE (Berkeley)";
  38. #endif not lint
  39.  
  40. #include "sprite.h"
  41.  
  42. /* The following mask is used to detect proper alignment of addresses
  43.  * for doing word operations instead of byte operations.  It is
  44.  * machine-dependent.  If none of the following bits are set in an
  45.  * address, then word-based transfers may be used.
  46.  */
  47.  
  48. #define WORDMASK 0x1
  49.  
  50.  
  51. /*
  52.  *----------------------------------------------------------------------
  53.  *
  54.  * Byte_Copy --
  55.  *
  56.  *    Copy numBytes from *sourcePtr to *destPtr.
  57.  *
  58.  * Results:
  59.  *    Contents at sourcePtr copied to contents at destPtr
  60.  *
  61.  * Side effects:
  62.  *    None.
  63.  *
  64.  *----------------------------------------------------------------------
  65.  */
  66.  
  67. void
  68. Byte_Copy(numBytes, sourcePtr, destPtr)
  69.     register int numBytes;    /* The number of bytes to copy */
  70.     Address sourcePtr;        /* Where to copy from */
  71.     Address destPtr;        /* Where to copy to */
  72. {
  73.     register int *sPtr = (int *) sourcePtr;
  74.     register int *dPtr = (int *) destPtr;
  75.     
  76.     /*
  77.      * If both the sourcePtr and the destPtr point to aligned
  78.      * addresses then copy as much as we can in large transfers.  Once
  79.      * we have less than 4 bytes to copy then it must be done by
  80.      * byte transfers.
  81.      */
  82.  
  83.     if (!((int) sPtr & WORDMASK) && !((int) dPtr & WORDMASK)) {
  84.     while (numBytes >= 4) {
  85.         *dPtr++ = *sPtr++;
  86.         numBytes -= 4;
  87.     }
  88.     sourcePtr = (char *) sPtr;
  89.     destPtr = (char *) dPtr;
  90.     }
  91.  
  92.     /*
  93.      * Copy the remaining bytes.
  94.      */
  95.  
  96.     while (numBytes > 0) {
  97.     *destPtr++ = *sourcePtr++;
  98.     numBytes--;
  99.     }
  100. }
  101.  
  102. /*
  103.  *----------------------------------------------------------------------
  104.  *
  105.  * Byte_Compare --
  106.  *
  107.  *    Compare numBytes from source to destination where sourcePtr points to 
  108.  *    the source address and destPtr points to the destination address.
  109.  *      This routine is optimized to do 4 byte compares.  However, if either 
  110.  *      sourcePtr or destPtr point to odd addresses then it is forced to
  111.  *      do single-byte compares.
  112.  *
  113.  * Results:
  114.  *    TRUE is returned if the memory at *sourcePtr is equal to the memory
  115.  *    at *destPtr.  FALSE is returned if there is a mismatch.
  116.  *
  117.  * Side effects:
  118.  *    None.
  119.  *
  120.  *----------------------------------------------------------------------
  121.  */
  122. #ifdef notdef
  123. Boolean
  124. Byte_Compare(numBytes, sourcePtr, destPtr)
  125.     register int numBytes;        /* The number of bytes to compare */
  126.     register Address sourcePtr;        /* Where to compare from */
  127.     register Address destPtr;        /* Where to compare to */
  128. {
  129.     /*
  130.      * If both the sourcePtr and the destPtr point to aligned addesses then
  131.      * compare as much as we can by 4-byte transfers.  Once we have less than
  132.      * 4 bytes to compare then it must be done by byte compares.
  133.      */
  134.  
  135.     if ((((int) sourcePtr & WORDMASK) == 0)
  136.         && (((int) destPtr & WORDMASK) == 0)) {
  137.     while (numBytes >= 4) {
  138.         if (*(int *) destPtr != *(int *) sourcePtr) {
  139.         return(FALSE);
  140.         }
  141.         sourcePtr += 4;
  142.         destPtr += 4;
  143.         numBytes -= 4;
  144.     }
  145.     }
  146.  
  147.     /*
  148.      * Compare the remaining bytes
  149.      */
  150.  
  151.     while (numBytes > 0) {
  152.     if (*destPtr++ != *sourcePtr++) {
  153.         return(FALSE);
  154.     }
  155.     numBytes--;
  156.     }
  157.  
  158.     return(TRUE);
  159. }
  160. #endif notdef
  161.  
  162. /*
  163.  *----------------------------------------------------------------------
  164.  *
  165.  * Byte_Zero --
  166.  *
  167.  *    Zero numBytes at the given address.  This routine is optimized to do 
  168.  *      4-byte zeroes.  However, if the address is odd then it is forced to
  169.  *      do single byte zeroes.
  170.  *
  171.  * Results:
  172.  *    numBytes bytes of zeroes are placed at *destPtr at the given address.
  173.  *
  174.  * Side effects:
  175.  *    None.
  176.  *
  177.  *----------------------------------------------------------------------
  178.  */
  179.  
  180. void
  181. Byte_Zero(numBytes, destPtr)
  182.     register int numBytes;    /* The number of bytes to zero. */
  183.     Address destPtr;        /* Where to zero. */
  184. {
  185.     register int *dPtr = (int *) destPtr;
  186.     
  187.     /*
  188.      * If the address is on an aligned boundary then zero as much
  189.      * as we can in big transfers (and also avoid loop overhead by
  190.      * storing many zeros per iteration).  Once we have less than
  191.      * 4 bytes to zero then it must be done by byte zeroes.
  192.      */
  193.  
  194.     if (((int) dPtr & WORDMASK) == 0) {
  195.     while (numBytes >= 4) {
  196.         *dPtr++ = 0;
  197.         numBytes -= 4;
  198.     }
  199.     destPtr = (char *) dPtr;
  200.     }
  201.  
  202.     /*
  203.      * Zero the remaining bytes
  204.      */
  205.  
  206.     while (numBytes > 0) {
  207.     *destPtr++ = 0;
  208.     numBytes--;
  209.     }
  210. }
  211.  
  212. /*
  213.  *----------------------------------------------------------------------
  214.  *
  215.  * Byte_Fill --
  216.  *
  217.  *    Fill numBytes at the given address.  This routine is optimized to do 
  218.  *      4-byte fills.  However, if the address is odd then it is forced to
  219.  *      do single byte fills.
  220.  *
  221.  * Results:
  222.  *    numBytes bytes of the fill byte are placed at *destPtr at the 
  223.  *    given address.
  224.  *
  225.  * Side effects:
  226.  *    None.
  227.  *
  228.  *----------------------------------------------------------------------
  229.  */
  230. #ifdef notdef
  231. void
  232. Byte_Fill(fillByte, numBytes, destPtr)
  233.     register unsigned char fillByte;    /* The byte to be filled in. */
  234.     register int numBytes;    /* The number of bytes to be filled in. */
  235.     Address destPtr;        /* Where to fill. */
  236. {
  237.     register unsigned int fillInt = 
  238.     (fillByte) | (fillByte << 8) | (fillByte << 16) | (fillByte << 24);
  239.  
  240.     register int *dPtr = (int *) destPtr;
  241.     
  242.     /*
  243.      * If the address is on an aligned boundary then fill in as much
  244.      * as we can in big transfers (and also avoid loop overhead by
  245.      * storing many fill ints per iteration).  Once we have less than
  246.      * 4 bytes to fill then it must be done by byte copies.
  247.      */
  248.  
  249.     if (((int) dPtr & WORDMASK) == 0) {
  250.     while (numBytes >= 32) {
  251.         *dPtr++ = fillInt;
  252.         *dPtr++ = fillInt;
  253.         *dPtr++ = fillInt;
  254.         *dPtr++ = fillInt;
  255.         *dPtr++ = fillInt;
  256.         *dPtr++ = fillInt;
  257.         *dPtr++ = fillInt;
  258.         *dPtr++ = fillInt;
  259.         numBytes -= 32;
  260.     }
  261.     while (numBytes >= 4) {
  262.         *dPtr++ = fillInt;
  263.         numBytes -= 4;
  264.     }
  265.     destPtr = (char *) dPtr;
  266.     }
  267.  
  268.     /*
  269.      * Fill in the remaining bytes
  270.      */
  271.  
  272.     while (numBytes > 0) {
  273.     *destPtr++ = fillByte;
  274.     numBytes--;
  275.     }
  276. }
  277. #endif notdef
  278. @
  279.